/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using ForwardWindow1Stride1 = WindowStrideTest<Pair, 1, 1>;
TYPED_TEST_SUITE(ForwardWindow1Stride1, GTestTypeTriples);
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4., 3., 6., 4., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4., 3., 6., 4., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  2., 4., 6.,  8.,
                                         3., 6., 9., 12., 4., 8., 12., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  2., 4., 6.,  8.,
                                         3., 6., 9., 12., 4., 8., 12., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7., 10., 15., 22., 23., 34., 31., 46.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7., 10., 15., 22., 23., 34., 31., 46.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11., 14., 17., 20., 23., 30.,
                                         37., 44., 35., 46., 57., 68.,
                                         47., 62., 77., 92.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11., 14., 17., 20., 23., 30.,
                                         37., 44., 35., 46., 57., 68.,
                                         47., 62., 77., 92.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140.,
                                         178., 220., 242., 300.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140.,
                                         178., 220., 242., 300.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90.,  100., 110., 120., 202., 228.,
                                         254., 280., 314., 356., 398., 440.,
                                         426., 484., 542., 600.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90.,  100., 110., 120., 202., 228.,
                                         254., 280., 314., 356., 398., 440.,
                                         426., 484., 542., 600.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 15., 22., 23., 34.,
                                         31., 46., 39., 58., 47., 70.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 15., 22., 23., 34.,
                                         31., 46., 39., 58., 47., 70.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 14., 17., 20., 23., 30., 37., 44.,  35., 46., 57.,  68.,
      47., 62., 77., 92., 59., 78., 97., 116., 71., 94., 117., 140.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 14., 17., 20., 23., 30., 37., 44.,  35., 46., 57.,  68.,
      47., 62., 77., 92., 59., 78., 97., 116., 71., 94., 117., 140.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150., 190., 230.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150., 190., 230.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140., 178., 220.,
                                         242., 300., 306., 380., 370., 460.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140., 178., 220.,
                                         242., 300., 306., 380., 370., 460.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100., 110., 120., 202., 228., 254., 280., 314., 356., 398., 440.,
      426., 484., 542., 600., 538., 612., 686., 760., 650., 740., 830., 920.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100., 110., 120., 202., 228., 254., 280., 314., 356., 398., 440.,
      426., 484., 542., 600., 538., 612., 686., 760., 650., 740., 830., 920.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35., 41., 47.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35., 41., 47.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 15., 22., 23., 34.,
                                         31., 46., 39., 58., 47., 70.,
                                         55., 82., 63., 94.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 15., 22., 23., 34.,
                                         31., 46., 39., 58., 47., 70.,
                                         55., 82., 63., 94.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17., 20.,  23.,  30.,  37., 44.,  35.,  46., 57.,
      68.,  47.,  62., 77.,  92.,  59.,  78., 97.,  116., 71., 94.,
      117., 140., 83., 110., 137., 164., 95., 126., 157., 188.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17., 20.,  23.,  30.,  37., 44.,  35.,  46., 57.,
      68.,  47.,  62., 77.,  92.,  59.,  78., 97.,  116., 71., 94.,
      117., 140., 83., 110., 137., 164., 95., 126., 157., 188.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150.,
                                         190., 230., 270., 310.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150.,
                                         190., 230., 270., 310.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140., 178., 220.,
                                         242., 300., 306., 380., 370., 460.,
                                         434., 540., 498., 620.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140., 178., 220.,
                                         242., 300., 306., 380., 370., 460.,
                                         434., 540., 498., 620.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100., 110., 120., 202., 228.,  254., 280., 314.,  356., 398.,
      440., 426., 484., 542., 600., 538.,  612., 686., 760.,  650., 740.,
      830., 920., 762., 868., 974., 1080., 874., 996., 1118., 1240.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100., 110., 120., 202., 228.,  254., 280., 314.,  356., 398.,
      440., 426., 484., 542., 600., 538.,  612., 686., 760.,  650., 740.,
      830., 920., 762., 868., 974., 1080., 874., 996., 1118., 1240.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 2., 4.,  3., 6.,
                                         4., 8., 5., 10., 6., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 15., 22., 23., 34.,
                                         31., 46., 39., 58., 47., 70.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 15., 22., 23., 34.,
                                         31., 46., 39., 58., 47., 70.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 14., 17., 20., 23., 30., 37., 44.,  35., 46., 57.,  68.,
      47., 62., 77., 92., 59., 78., 97., 116., 71., 94., 117., 140.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 14., 17., 20., 23., 30., 37., 44.,  35., 46., 57.,  68.,
      47., 62., 77., 92., 59., 78., 97., 116., 71., 94., 117., 140.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150., 190., 230.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30., 70., 110., 150., 190., 230.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140., 178., 220.,
                                         242., 300., 306., 380., 370., 460.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140., 178., 220.,
                                         242., 300., 306., 380., 370., 460.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100., 110., 120., 202., 228., 254., 280., 314., 356., 398., 440.,
      426., 484., 542., 600., 538., 612., 686., 760., 650., 740., 830., 920.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100., 110., 120., 202., 228., 254., 280., 314., 356., 398., 440.,
      426., 484., 542., 600., 538., 612., 686., 760., 650., 740., 830., 920.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8., 9.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8., 9.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,
                                         4., 8.,  5., 10., 6., 12.,
                                         7., 14., 8., 16., 9., 18.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,
                                         4., 8.,  5., 10., 6., 12.,
                                         7., 14., 8., 16., 9., 18.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1., 2.,  3.,  4.,  2., 4.,  6.,  8.,  3., 6.,  9.,  12.,
      4., 8.,  12., 16., 5., 10., 15., 20., 6., 12., 18., 24.,
      7., 14., 21., 28., 8., 16., 24., 32., 9., 18., 27., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1., 2.,  3.,  4.,  2., 4.,  6.,  8.,  3., 6.,  9.,  12.,
      4., 8.,  12., 16., 5., 10., 15., 20., 6., 12., 18., 24.,
      7., 14., 21., 28., 8., 16., 24., 32., 9., 18., 27., 36.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,
                                         35., 41., 47., 53.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,
                                         35., 41., 47., 53.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 15., 22., 23., 34.,
                                         31., 46., 39., 58., 47., 70.,
                                         55., 82., 63., 94., 71., 106.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 15., 22., 23., 34.,
                                         31., 46., 39., 58., 47., 70.,
                                         55., 82., 63., 94., 71., 106.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 14.,  17.,  20.,  23., 30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47., 62.,  77.,  92.,  59., 78.,  97.,  116., 71.,  94.,  117., 140.,
      83., 110., 137., 164., 95., 126., 157., 188., 107., 142., 177., 212.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 14.,  17.,  20.,  23., 30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47., 62.,  77.,  92.,  59., 78.,  97.,  116., 71.,  94.,  117., 140.,
      83., 110., 137., 164., 95., 126., 157., 188., 107., 142., 177., 212.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190.,
                                         230., 270., 310., 350.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190.,
                                         230., 270., 310., 350.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140., 178., 220.,
                                         242., 300., 306., 380., 370., 460.,
                                         434., 540., 498., 620., 562., 700.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140., 178., 220.,
                                         242., 300., 306., 380., 370., 460.,
                                         434., 540., 498., 620., 562., 700.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100., 110., 120.,  202.,  228., 254.,  280.,  314.,
      356.,  398., 440., 426.,  484.,  542., 600.,  538.,  612.,
      686.,  760., 650., 740.,  830.,  920., 762.,  868.,  974.,
      1080., 874., 996., 1118., 1240., 986., 1124., 1262., 1400.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100., 110., 120.,  202.,  228., 254.,  280.,  314.,
      356.,  398., 440., 426.,  484.,  542., 600.,  538.,  612.,
      686.,  760., 650., 740.,  830.,  920., 762.,  868.,  974.,
      1080., 874., 996., 1118., 1240., 986., 1124., 1262., 1400.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  10., 15., 22., 23., 34.,  31., 46.,  39., 58.,  47., 70.,
      55., 82., 63., 94., 71., 106., 79., 118., 87., 130., 95., 142.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  10., 15., 22., 23., 34.,  31., 46.,  39., 58.,  47., 70.,
      55., 82., 63., 94., 71., 106., 79., 118., 87., 130., 95., 142.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,  60.,  114., 140., 178., 220., 242., 300., 306., 380., 370., 460.,
      434., 540., 498., 620., 562., 700., 626., 780., 690., 860., 754., 940.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,  60.,  114., 140., 178., 220., 242., 300., 306., 380., 370., 460.,
      434., 540., 498., 620., 562., 700., 626., 780., 690., 860., 754., 940.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4., 5., 6., 7., 8.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2., 4.,  3., 6.,  4., 8.,
                                         5., 10., 6., 12., 7., 14., 8., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  2., 4.,  6.,  8.,
                                         3., 6.,  9.,  12., 4., 8.,  12., 16.,
                                         5., 10., 15., 20., 6., 12., 18., 24.,
                                         7., 14., 21., 28., 8., 16., 24., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35., 41., 47.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5., 11., 17., 23., 29., 35., 41., 47.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 15., 22., 23., 34.,
                                         31., 46., 39., 58., 47., 70.,
                                         55., 82., 63., 94.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  10., 15., 22., 23., 34.,
                                         31., 46., 39., 58., 47., 70.,
                                         55., 82., 63., 94.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17., 20.,  23.,  30.,  37., 44.,  35.,  46., 57.,
      68.,  47.,  62., 77.,  92.,  59.,  78., 97.,  116., 71., 94.,
      117., 140., 83., 110., 137., 164., 95., 126., 157., 188.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17., 20.,  23.,  30.,  37., 44.,  35.,  46., 57.,
      68.,  47.,  62., 77.,  92.,  59.,  78., 97.,  116., 71., 94.,
      117., 140., 83., 110., 137., 164., 95., 126., 157., 188.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150.,
                                         190., 230., 270., 310.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150.,
                                         190., 230., 270., 310.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140., 178., 220.,
                                         242., 300., 306., 380., 370., 460.,
                                         434., 540., 498., 620.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50.,  60.,  114., 140., 178., 220.,
                                         242., 300., 306., 380., 370., 460.,
                                         434., 540., 498., 620.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100., 110., 120., 202., 228.,  254., 280., 314.,  356., 398.,
      440., 426., 484., 542., 600., 538.,  612., 686., 760.,  650., 740.,
      830., 920., 762., 868., 974., 1080., 874., 996., 1118., 1240.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,  100., 110., 120., 202., 228.,  254., 280., 314.,  356., 398.,
      440., 426., 484., 542., 600., 538.,  612., 686., 760.,  650., 740.,
      830., 920., 762., 868., 974., 1080., 874., 996., 1118., 1240.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  10., 15., 22., 23., 34.,  31., 46.,  39., 58.,  47., 70.,
      55., 82., 63., 94., 71., 106., 79., 118., 87., 130., 95., 142.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  10., 15., 22., 23., 34.,  31., 46.,  39., 58.,  47., 70.,
      55., 82., 63., 94., 71., 106., 79., 118., 87., 130., 95., 142.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,  60.,  114., 140., 178., 220., 242., 300., 306., 380., 370., 460.,
      434., 540., 498., 620., 562., 700., 626., 780., 690., 860., 754., 940.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,  60.,  114., 140., 178., 220., 242., 300., 306., 380., 370., 460.,
      434., 540., 498., 620., 562., 700., 626., 780., 690., 860., 754., 940.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  3.,  4.,  5.,  6.,  7.,  8.,
                                         9., 10., 11., 12., 13., 14., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,
      12., 7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22.,
      12., 24., 13., 26., 14., 28., 15., 30., 16., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,
      12., 7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22.,
      12., 24., 13., 26., 14., 28., 15., 30., 16., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,
      8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14.,
      21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30.,
      40., 11., 22., 33., 44., 12., 24., 36., 48., 13., 26., 39., 52.,
      14., 28., 42., 56., 15., 30., 45., 60., 16., 32., 48., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,
      8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14.,
      21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30.,
      40., 11., 22., 33., 44., 12., 24., 36., 48., 13., 26., 39., 52.,
      14., 28., 42., 56., 15., 30., 45., 60., 16., 32., 48., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.,
                                         77., 83., 89., 95.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.,
                                         77., 83., 89., 95.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58., 47.,
      70., 55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87., 130.,
      95., 142., 103., 154., 111., 166., 119., 178., 127., 190.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58., 47.,
      70., 55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87., 130.,
      95., 142., 103., 154., 111., 166., 119., 178., 127., 190.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,
      68.,  47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,
      117., 140., 83.,  110., 137., 164., 95.,  126., 157., 188., 107.,
      142., 177., 212., 119., 158., 197., 236., 131., 174., 217., 260.,
      143., 190., 237., 284., 155., 206., 257., 308., 167., 222., 277.,
      332., 179., 238., 297., 356., 191., 254., 317., 380.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,
      68.,  47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,
      117., 140., 83.,  110., 137., 164., 95.,  126., 157., 188., 107.,
      142., 177., 212., 119., 158., 197., 236., 131., 174., 217., 260.,
      143., 190., 237., 284., 155., 206., 257., 308., 167., 222., 277.,
      332., 179., 238., 297., 356., 191., 254., 317., 380.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,  60.,  114., 140.,  178., 220.,  242., 300.,  306.,  380., 370.,
      460., 434., 540., 498.,  620., 562.,  700., 626.,  780.,  690., 860.,
      754., 940., 818., 1020., 882., 1100., 946., 1180., 1010., 1260.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,  60.,  114., 140.,  178., 220.,  242., 300.,  306.,  380., 370.,
      460., 434., 540., 498.,  620., 562.,  700., 626.,  780.,  690., 860.,
      754., 940., 818., 1020., 882., 1100., 946., 1180., 1010., 1260.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2., 3., 4.,  5.,  6.,
                                         7., 8., 9., 10., 11., 12.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1., 2.,  2.,  4.,  3.,  6.,  4.,  8.,
                                         5., 10., 6.,  12., 7.,  14., 8.,  16.,
                                         9., 18., 10., 20., 11., 22., 12., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12.,
      4.,  8.,  12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24.,
      7.,  14., 21., 28., 8.,  16., 24., 32., 9.,  18., 27., 36.,
      10., 20., 30., 40., 11., 22., 33., 44., 12., 24., 36., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29., 35.,
                                         41., 47., 53., 59., 65., 71.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  10., 15., 22., 23., 34.,  31., 46.,  39., 58.,  47., 70.,
      55., 82., 63., 94., 71., 106., 79., 118., 87., 130., 95., 142.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  10., 15., 22., 23., 34.,  31., 46.,  39., 58.,  47., 70.,
      55., 82., 63., 94., 71., 106., 79., 118., 87., 130., 95., 142.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,  60.,  114., 140., 178., 220., 242., 300., 306., 380., 370., 460.,
      434., 540., 498., 620., 562., 700., 626., 780., 690., 860., 754., 940.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,  60.,  114., 140., 178., 220., 242., 300., 306., 380., 370., 460.,
      434., 540., 498., 620., 562., 700., 626., 780., 690., 860., 754., 940.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,  35.,
                                         41., 47., 53., 59., 65.,  71.,
                                         77., 83., 89., 95., 101., 107.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,  35.,
                                         41., 47., 53., 59., 65.,  71.,
                                         77., 83., 89., 95., 101., 107.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630., 670., 710.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630., 670., 710.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,  114.,  140.,  178.,  220.,  242.,  300.,  306.,
      380.,  370., 460.,  434.,  540.,  498.,  620.,  562.,  700.,
      626.,  780., 690.,  860.,  754.,  940.,  818.,  1020., 882.,
      1100., 946., 1180., 1010., 1260., 1074., 1340., 1138., 1420.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,  114.,  140.,  178.,  220.,  242.,  300.,  306.,
      380.,  370., 460.,  434.,  540.,  498.,  620.,  562.,  700.,
      626.,  780., 690.,  860.,  754.,  940.,  818.,  1020., 882.,
      1100., 946., 1180., 1010., 1260., 1074., 1340., 1138., 1420.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,
      356.,  398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,
      686.,  760.,  650.,  740.,  830.,  920.,  762.,  868.,  974.,
      1080., 874.,  996.,  1118., 1240., 986.,  1124., 1262., 1400.,
      1098., 1252., 1406., 1560., 1210., 1380., 1550., 1720., 1322.,
      1508., 1694., 1880., 1434., 1636., 1838., 2040., 1546., 1764.,
      1982., 2200., 1658., 1892., 2126., 2360., 1770., 2020., 2270.,
      2520., 1882., 2148., 2414., 2680., 1994., 2276., 2558., 2840.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,
      356.,  398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,
      686.,  760.,  650.,  740.,  830.,  920.,  762.,  868.,  974.,
      1080., 874.,  996.,  1118., 1240., 986.,  1124., 1262., 1400.,
      1098., 1252., 1406., 1560., 1210., 1380., 1550., 1720., 1322.,
      1508., 1694., 1880., 1434., 1636., 1838., 2040., 1546., 1764.,
      1982., 2200., 1658., 1892., 2126., 2360., 1770., 2020., 2270.,
      2520., 1882., 2148., 2414., 2680., 1994., 2276., 2558., 2840.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23., 29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77., 83., 89., 95., 101., 107., 113., 119., 125., 131., 137., 143.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23., 29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77., 83., 89., 95., 101., 107., 113., 119., 125., 131., 137., 143.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.,
      151., 226., 159., 238., 167., 250., 175., 262., 183., 274., 191., 286.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.,
      151., 226., 159., 238., 167., 250., 175., 262., 183., 274., 191., 286.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.,
      227., 302., 377., 452., 239., 318., 397., 476., 251., 334., 417., 500.,
      263., 350., 437., 524., 275., 366., 457., 548., 287., 382., 477., 572.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.,
      227., 302., 377., 452., 239., 318., 397., 476., 251., 334., 417., 500.,
      263., 350., 437., 524., 275., 366., 457., 548., 287., 382., 477., 572.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310., 350., 390., 430., 470.,
      510., 550., 590., 630., 670., 710., 750., 790., 830., 870., 910., 950.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310., 350., 390., 430., 470.,
      510., 550., 590., 630., 670., 710., 750., 790., 830., 870., 910., 950.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,  380.,
      370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,  626.,  780.,
      690.,  860.,  754.,  940.,  818.,  1020., 882.,  1100., 946.,  1180.,
      1010., 1260., 1074., 1340., 1138., 1420., 1202., 1500., 1266., 1580.,
      1330., 1660., 1394., 1740., 1458., 1820., 1522., 1900.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,  380.,
      370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,  626.,  780.,
      690.,  860.,  754.,  940.,  818.,  1020., 882.,  1100., 946.,  1180.,
      1010., 1260., 1074., 1340., 1138., 1420., 1202., 1500., 1266., 1580.,
      1330., 1660., 1394., 1740., 1458., 1820., 1522., 1900.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  2.,  3.,  4.,  5.,  6.,
                                         7.,  8.,  9.,  10., 11., 12.,
                                         13., 14., 15., 16., 17., 18.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,  12.,
      16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28., 8.,  16.,
      24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22., 33., 44., 12.,
      24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56., 15., 30., 45., 60.,
      16., 32., 48., 64., 17., 34., 51., 68., 18., 36., 54., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,  35.,
                                         41., 47., 53., 59., 65.,  71.,
                                         77., 83., 89., 95., 101., 107.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,  11., 17., 23., 29.,  35.,
                                         41., 47., 53., 59., 65.,  71.,
                                         77., 83., 89., 95., 101., 107.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630., 670., 710.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.,  70.,  110., 150., 190., 230.,
                                         270., 310., 350., 390., 430., 470.,
                                         510., 550., 590., 630., 670., 710.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,  114.,  140.,  178.,  220.,  242.,  300.,  306.,
      380.,  370., 460.,  434.,  540.,  498.,  620.,  562.,  700.,
      626.,  780., 690.,  860.,  754.,  940.,  818.,  1020., 882.,
      1100., 946., 1180., 1010., 1260., 1074., 1340., 1138., 1420.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,  114.,  140.,  178.,  220.,  242.,  300.,  306.,
      380.,  370., 460.,  434.,  540.,  498.,  620.,  562.,  700.,
      626.,  780., 690.,  860.,  754.,  940.,  818.,  1020., 882.,
      1100., 946., 1180., 1010., 1260., 1074., 1340., 1138., 1420.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,
      356.,  398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,
      686.,  760.,  650.,  740.,  830.,  920.,  762.,  868.,  974.,
      1080., 874.,  996.,  1118., 1240., 986.,  1124., 1262., 1400.,
      1098., 1252., 1406., 1560., 1210., 1380., 1550., 1720., 1322.,
      1508., 1694., 1880., 1434., 1636., 1838., 2040., 1546., 1764.,
      1982., 2200., 1658., 1892., 2126., 2360., 1770., 2020., 2270.,
      2520., 1882., 2148., 2414., 2680., 1994., 2276., 2558., 2840.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,
      356.,  398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,
      686.,  760.,  650.,  740.,  830.,  920.,  762.,  868.,  974.,
      1080., 874.,  996.,  1118., 1240., 986.,  1124., 1262., 1400.,
      1098., 1252., 1406., 1560., 1210., 1380., 1550., 1720., 1322.,
      1508., 1694., 1880., 1434., 1636., 1838., 2040., 1546., 1764.,
      1982., 2200., 1658., 1892., 2126., 2360., 1770., 2020., 2270.,
      2520., 1882., 2148., 2414., 2680., 1994., 2276., 2558., 2840.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12., 13., 14.,
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,  4.,  2.,  4.,   6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16.,  5.,  10., 15., 20.,  6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16.,  24., 32., 9.,  18.,  27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44.,  12., 24., 36., 48.,  13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30.,  45., 60., 16., 32.,  48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72.,  19., 38., 57., 76.,  20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44.,  66., 88., 23., 46.,  69., 92., 24., 48., 72., 96., 25., 50.,
      75., 100., 26., 52., 78., 104., 27., 54., 81., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,   3.,  4.,  2.,  4.,   6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16.,  5.,  10., 15., 20.,  6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16.,  24., 32., 9.,  18.,  27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44.,  12., 24., 36., 48.,  13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30.,  45., 60., 16., 32.,  48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72.,  19., 38., 57., 76.,  20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44.,  66., 88., 23., 46.,  69., 92., 24., 48., 72., 96., 25., 50.,
      75., 100., 26., 52., 78., 104., 27., 54., 81., 108.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,
      59.,  65.,  71.,  77.,  83.,  89.,  95.,  101., 107.,
      113., 119., 125., 131., 137., 143., 149., 155., 161.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,
      59.,  65.,  71.,  77.,  83.,  89.,  95.,  101., 107.,
      113., 119., 125., 131., 137., 143., 149., 155., 161.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,
      70.,  55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130.,
      95.,  142., 103., 154., 111., 166., 119., 178., 127., 190., 135.,
      202., 143., 214., 151., 226., 159., 238., 167., 250., 175., 262.,
      183., 274., 191., 286., 199., 298., 207., 310., 215., 322.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,
      70.,  55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130.,
      95.,  142., 103., 154., 111., 166., 119., 178., 127., 190., 135.,
      202., 143., 214., 151., 226., 159., 238., 167., 250., 175., 262.,
      183., 274., 191., 286., 199., 298., 207., 310., 215., 322.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.,
      227., 302., 377., 452., 239., 318., 397., 476., 251., 334., 417., 500.,
      263., 350., 437., 524., 275., 366., 457., 548., 287., 382., 477., 572.,
      299., 398., 497., 596., 311., 414., 517., 620., 323., 430., 537., 644.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.,
      227., 302., 377., 452., 239., 318., 397., 476., 251., 334., 417., 500.,
      263., 350., 437., 524., 275., 366., 457., 548., 287., 382., 477., 572.,
      299., 398., 497., 596., 311., 414., 517., 620., 323., 430., 537., 644.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310.,  350.,
      390., 430., 470., 510., 550., 590., 630., 670.,  710.,
      750., 790., 830., 870., 910., 950., 990., 1030., 1070.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310.,  350.,
      390., 430., 470., 510., 550., 590., 630., 670.,  710.,
      750., 790., 830., 870., 910., 950., 990., 1030., 1070.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,
      380.,  370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,
      626.,  780.,  690.,  860.,  754.,  940.,  818.,  1020., 882.,
      1100., 946.,  1180., 1010., 1260., 1074., 1340., 1138., 1420.,
      1202., 1500., 1266., 1580., 1330., 1660., 1394., 1740., 1458.,
      1820., 1522., 1900., 1586., 1980., 1650., 2060., 1714., 2140.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,
      380.,  370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,
      626.,  780.,  690.,  860.,  754.,  940.,  818.,  1020., 882.,
      1100., 946.,  1180., 1010., 1260., 1074., 1340., 1138., 1420.,
      1202., 1500., 1266., 1580., 1330., 1660., 1394., 1740., 1458.,
      1820., 1522., 1900., 1586., 1980., 1650., 2060., 1714., 2140.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800., 2778., 3172., 3566., 3960.,
      2890., 3300., 3710., 4120., 3002., 3428., 3854., 4280.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800., 2778., 3172., 3566., 3960.,
      2890., 3300., 3710., 4120., 3002., 3428., 3854., 4280.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.,
      151., 226., 159., 238., 167., 250., 175., 262., 183., 274., 191., 286.,
      199., 298., 207., 310., 215., 322., 223., 334., 231., 346., 239., 358.,
      247., 370., 255., 382., 263., 394., 271., 406., 279., 418., 287., 430.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.,
      151., 226., 159., 238., 167., 250., 175., 262., 183., 274., 191., 286.,
      199., 298., 207., 310., 215., 322., 223., 334., 231., 346., 239., 358.,
      247., 370., 255., 382., 263., 394., 271., 406., 279., 418., 287., 430.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.,
      227., 302., 377., 452., 239., 318., 397., 476., 251., 334., 417., 500.,
      263., 350., 437., 524., 275., 366., 457., 548., 287., 382., 477., 572.,
      299., 398., 497., 596., 311., 414., 517., 620., 323., 430., 537., 644.,
      335., 446., 557., 668., 347., 462., 577., 692., 359., 478., 597., 716.,
      371., 494., 617., 740., 383., 510., 637., 764., 395., 526., 657., 788.,
      407., 542., 677., 812., 419., 558., 697., 836., 431., 574., 717., 860.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.,
      227., 302., 377., 452., 239., 318., 397., 476., 251., 334., 417., 500.,
      263., 350., 437., 524., 275., 366., 457., 548., 287., 382., 477., 572.,
      299., 398., 497., 596., 311., 414., 517., 620., 323., 430., 537., 644.,
      335., 446., 557., 668., 347., 462., 577., 692., 359., 478., 597., 716.,
      371., 494., 617., 740., 383., 510., 637., 764., 395., 526., 657., 788.,
      407., 542., 677., 812., 419., 558., 697., 836., 431., 574., 717., 860.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,
      390.,  430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,
      750.,  790.,  830.,  870.,  910.,  950.,  990.,  1030., 1070.,
      1110., 1150., 1190., 1230., 1270., 1310., 1350., 1390., 1430.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,
      390.,  430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,
      750.,  790.,  830.,  870.,  910.,  950.,  990.,  1030., 1070.,
      1110., 1150., 1190., 1230., 1270., 1310., 1350., 1390., 1430.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,
      380.,  370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,
      626.,  780.,  690.,  860.,  754.,  940.,  818.,  1020., 882.,
      1100., 946.,  1180., 1010., 1260., 1074., 1340., 1138., 1420.,
      1202., 1500., 1266., 1580., 1330., 1660., 1394., 1740., 1458.,
      1820., 1522., 1900., 1586., 1980., 1650., 2060., 1714., 2140.,
      1778., 2220., 1842., 2300., 1906., 2380., 1970., 2460., 2034.,
      2540., 2098., 2620., 2162., 2700., 2226., 2780., 2290., 2860.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,
      380.,  370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,
      626.,  780.,  690.,  860.,  754.,  940.,  818.,  1020., 882.,
      1100., 946.,  1180., 1010., 1260., 1074., 1340., 1138., 1420.,
      1202., 1500., 1266., 1580., 1330., 1660., 1394., 1740., 1458.,
      1820., 1522., 1900., 1586., 1980., 1650., 2060., 1714., 2140.,
      1778., 2220., 1842., 2300., 1906., 2380., 1970., 2460., 2034.,
      2540., 2098., 2620., 2162., 2700., 2226., 2780., 2290., 2860.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800., 2778., 3172., 3566., 3960.,
      2890., 3300., 3710., 4120., 3002., 3428., 3854., 4280., 3114., 3556.,
      3998., 4440., 3226., 3684., 4142., 4600., 3338., 3812., 4286., 4760.,
      3450., 3940., 4430., 4920., 3562., 4068., 4574., 5080., 3674., 4196.,
      4718., 5240., 3786., 4324., 4862., 5400., 3898., 4452., 5006., 5560.,
      4010., 4580., 5150., 5720.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800., 2778., 3172., 3566., 3960.,
      2890., 3300., 3710., 4120., 3002., 3428., 3854., 4280., 3114., 3556.,
      3998., 4440., 3226., 3684., 4142., 4600., 3338., 3812., 4286., 4760.,
      3450., 3940., 4430., 4920., 3562., 4068., 4574., 5080., 3674., 4196.,
      4718., 5240., 3786., 4324., 4862., 5400., 3898., 4452., 5006., 5560.,
      4010., 4580., 5150., 5720.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12.,
      7.,  14., 8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24.,
      13., 26., 14., 28., 15., 30., 16., 32., 17., 34., 18., 36.,
      19., 38., 20., 40., 21., 42., 22., 44., 23., 46., 24., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  2.,  4.,  6.,  8.,  3.,  6.,  9.,  12., 4.,  8.,
      12., 16., 5.,  10., 15., 20., 6.,  12., 18., 24., 7.,  14., 21., 28.,
      8.,  16., 24., 32., 9.,  18., 27., 36., 10., 20., 30., 40., 11., 22.,
      33., 44., 12., 24., 36., 48., 13., 26., 39., 52., 14., 28., 42., 56.,
      15., 30., 45., 60., 16., 32., 48., 64., 17., 34., 51., 68., 18., 36.,
      54., 72., 19., 38., 57., 76., 20., 40., 60., 80., 21., 42., 63., 84.,
      22., 44., 66., 88., 23., 46., 69., 92., 24., 48., 72., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23., 29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77., 83., 89., 95., 101., 107., 113., 119., 125., 131., 137., 143.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,  11., 17., 23., 29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77., 83., 89., 95., 101., 107., 113., 119., 125., 131., 137., 143.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.,
      151., 226., 159., 238., 167., 250., 175., 262., 183., 274., 191., 286.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.,
      151., 226., 159., 238., 167., 250., 175., 262., 183., 274., 191., 286.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.,
      227., 302., 377., 452., 239., 318., 397., 476., 251., 334., 417., 500.,
      263., 350., 437., 524., 275., 366., 457., 548., 287., 382., 477., 572.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.,
      227., 302., 377., 452., 239., 318., 397., 476., 251., 334., 417., 500.,
      263., 350., 437., 524., 275., 366., 457., 548., 287., 382., 477., 572.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310., 350., 390., 430., 470.,
      510., 550., 590., 630., 670., 710., 750., 790., 830., 870., 910., 950.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  70.,  110., 150., 190., 230., 270., 310., 350., 390., 430., 470.,
      510., 550., 590., 630., 670., 710., 750., 790., 830., 870., 910., 950.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,  380.,
      370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,  626.,  780.,
      690.,  860.,  754.,  940.,  818.,  1020., 882.,  1100., 946.,  1180.,
      1010., 1260., 1074., 1340., 1138., 1420., 1202., 1500., 1266., 1580.,
      1330., 1660., 1394., 1740., 1458., 1820., 1522., 1900.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,  380.,
      370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,  626.,  780.,
      690.,  860.,  754.,  940.,  818.,  1020., 882.,  1100., 946.,  1180.,
      1010., 1260., 1074., 1340., 1138., 1420., 1202., 1500., 1266., 1580.,
      1330., 1660., 1394., 1740., 1458., 1820., 1522., 1900.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14., 8.,
      16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28., 15., 30.,
      16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42., 22., 44., 23.,
      46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56., 29., 58., 30., 60.,
      31., 62., 32., 64., 33., 66., 34., 68., 35., 70., 36., 72.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.,
      151., 226., 159., 238., 167., 250., 175., 262., 183., 274., 191., 286.,
      199., 298., 207., 310., 215., 322., 223., 334., 231., 346., 239., 358.,
      247., 370., 255., 382., 263., 394., 271., 406., 279., 418., 287., 430.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.,
      151., 226., 159., 238., 167., 250., 175., 262., 183., 274., 191., 286.,
      199., 298., 207., 310., 215., 322., 223., 334., 231., 346., 239., 358.,
      247., 370., 255., 382., 263., 394., 271., 406., 279., 418., 287., 430.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.,
      227., 302., 377., 452., 239., 318., 397., 476., 251., 334., 417., 500.,
      263., 350., 437., 524., 275., 366., 457., 548., 287., 382., 477., 572.,
      299., 398., 497., 596., 311., 414., 517., 620., 323., 430., 537., 644.,
      335., 446., 557., 668., 347., 462., 577., 692., 359., 478., 597., 716.,
      371., 494., 617., 740., 383., 510., 637., 764., 395., 526., 657., 788.,
      407., 542., 677., 812., 419., 558., 697., 836., 431., 574., 717., 860.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  14.,  17.,  20.,  23.,  30.,  37.,  44.,  35.,  46.,  57.,  68.,
      47.,  62.,  77.,  92.,  59.,  78.,  97.,  116., 71.,  94.,  117., 140.,
      83.,  110., 137., 164., 95.,  126., 157., 188., 107., 142., 177., 212.,
      119., 158., 197., 236., 131., 174., 217., 260., 143., 190., 237., 284.,
      155., 206., 257., 308., 167., 222., 277., 332., 179., 238., 297., 356.,
      191., 254., 317., 380., 203., 270., 337., 404., 215., 286., 357., 428.,
      227., 302., 377., 452., 239., 318., 397., 476., 251., 334., 417., 500.,
      263., 350., 437., 524., 275., 366., 457., 548., 287., 382., 477., 572.,
      299., 398., 497., 596., 311., 414., 517., 620., 323., 430., 537., 644.,
      335., 446., 557., 668., 347., 462., 577., 692., 359., 478., 597., 716.,
      371., 494., 617., 740., 383., 510., 637., 764., 395., 526., 657., 788.,
      407., 542., 677., 812., 419., 558., 697., 836., 431., 574., 717., 860.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,
      390.,  430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,
      750.,  790.,  830.,  870.,  910.,  950.,  990.,  1030., 1070.,
      1110., 1150., 1190., 1230., 1270., 1310., 1350., 1390., 1430.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,
      390.,  430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,
      750.,  790.,  830.,  870.,  910.,  950.,  990.,  1030., 1070.,
      1110., 1150., 1190., 1230., 1270., 1310., 1350., 1390., 1430.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,
      380.,  370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,
      626.,  780.,  690.,  860.,  754.,  940.,  818.,  1020., 882.,
      1100., 946.,  1180., 1010., 1260., 1074., 1340., 1138., 1420.,
      1202., 1500., 1266., 1580., 1330., 1660., 1394., 1740., 1458.,
      1820., 1522., 1900., 1586., 1980., 1650., 2060., 1714., 2140.,
      1778., 2220., 1842., 2300., 1906., 2380., 1970., 2460., 2034.,
      2540., 2098., 2620., 2162., 2700., 2226., 2780., 2290., 2860.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,
      380.,  370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,
      626.,  780.,  690.,  860.,  754.,  940.,  818.,  1020., 882.,
      1100., 946.,  1180., 1010., 1260., 1074., 1340., 1138., 1420.,
      1202., 1500., 1266., 1580., 1330., 1660., 1394., 1740., 1458.,
      1820., 1522., 1900., 1586., 1980., 1650., 2060., 1714., 2140.,
      1778., 2220., 1842., 2300., 1906., 2380., 1970., 2460., 2034.,
      2540., 2098., 2620., 2162., 2700., 2226., 2780., 2290., 2860.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800., 2778., 3172., 3566., 3960.,
      2890., 3300., 3710., 4120., 3002., 3428., 3854., 4280., 3114., 3556.,
      3998., 4440., 3226., 3684., 4142., 4600., 3338., 3812., 4286., 4760.,
      3450., 3940., 4430., 4920., 3562., 4068., 4574., 5080., 3674., 4196.,
      4718., 5240., 3786., 4324., 4862., 5400., 3898., 4452., 5006., 5560.,
      4010., 4580., 5150., 5720.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800., 2778., 3172., 3566., 3960.,
      2890., 3300., 3710., 4120., 3002., 3428., 3854., 4280., 3114., 3556.,
      3998., 4440., 3226., 3684., 4142., 4600., 3338., 3812., 4286., 4760.,
      3450., 3940., 4430., 4920., 3562., 4068., 4574., 5080., 3674., 4196.,
      4718., 5240., 3786., 4324., 4862., 5400., 3898., 4452., 5006., 5560.,
      4010., 4580., 5150., 5720.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
      13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24.,
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36.,
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56.,
      29., 58., 30., 60., 31., 62., 32., 64., 33., 66., 34., 68., 35., 70.,
      36., 72., 37., 74., 38., 76., 39., 78., 40., 80., 41., 82., 42., 84.,
      43., 86., 44., 88., 45., 90., 46., 92., 47., 94., 48., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  2.,  4.,  3.,  6.,  4.,  8.,  5.,  10., 6.,  12., 7.,  14.,
      8.,  16., 9.,  18., 10., 20., 11., 22., 12., 24., 13., 26., 14., 28.,
      15., 30., 16., 32., 17., 34., 18., 36., 19., 38., 20., 40., 21., 42.,
      22., 44., 23., 46., 24., 48., 25., 50., 26., 52., 27., 54., 28., 56.,
      29., 58., 30., 60., 31., 62., 32., 64., 33., 66., 34., 68., 35., 70.,
      36., 72., 37., 74., 38., 76., 39., 78., 40., 80., 41., 82., 42., 84.,
      43., 86., 44., 88., 45., 90., 46., 92., 47., 94., 48., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.,
      37., 74., 111., 148., 38., 76., 114., 152., 39., 78., 117., 156.,
      40., 80., 120., 160., 41., 82., 123., 164., 42., 84., 126., 168.,
      43., 86., 129., 172., 44., 88., 132., 176., 45., 90., 135., 180.,
      46., 92., 138., 184., 47., 94., 141., 188., 48., 96., 144., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  3.,   4.,   2.,  4.,  6.,   8.,   3.,  6.,  9.,   12.,
      4.,  8.,  12.,  16.,  5.,  10., 15.,  20.,  6.,  12., 18.,  24.,
      7.,  14., 21.,  28.,  8.,  16., 24.,  32.,  9.,  18., 27.,  36.,
      10., 20., 30.,  40.,  11., 22., 33.,  44.,  12., 24., 36.,  48.,
      13., 26., 39.,  52.,  14., 28., 42.,  56.,  15., 30., 45.,  60.,
      16., 32., 48.,  64.,  17., 34., 51.,  68.,  18., 36., 54.,  72.,
      19., 38., 57.,  76.,  20., 40., 60.,  80.,  21., 42., 63.,  84.,
      22., 44., 66.,  88.,  23., 46., 69.,  92.,  24., 48., 72.,  96.,
      25., 50., 75.,  100., 26., 52., 78.,  104., 27., 54., 81.,  108.,
      28., 56., 84.,  112., 29., 58., 87.,  116., 30., 60., 90.,  120.,
      31., 62., 93.,  124., 32., 64., 96.,  128., 33., 66., 99.,  132.,
      34., 68., 102., 136., 35., 70., 105., 140., 36., 72., 108., 144.,
      37., 74., 111., 148., 38., 76., 114., 152., 39., 78., 117., 156.,
      40., 80., 120., 160., 41., 82., 123., 164., 42., 84., 126., 168.,
      43., 86., 129., 172., 44., 88., 132., 176., 45., 90., 135., 180.,
      46., 92., 138., 184., 47., 94., 141., 188., 48., 96., 144., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.,
      221., 227., 233., 239., 245., 251., 257., 263., 269., 275., 281., 287.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  17.,  23.,  29.,  35.,  41.,  47.,  53.,  59.,  65.,  71.,
      77.,  83.,  89.,  95.,  101., 107., 113., 119., 125., 131., 137., 143.,
      149., 155., 161., 167., 173., 179., 185., 191., 197., 203., 209., 215.,
      221., 227., 233., 239., 245., 251., 257., 263., 269., 275., 281., 287.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.,
      151., 226., 159., 238., 167., 250., 175., 262., 183., 274., 191., 286.,
      199., 298., 207., 310., 215., 322., 223., 334., 231., 346., 239., 358.,
      247., 370., 255., 382., 263., 394., 271., 406., 279., 418., 287., 430.,
      295., 442., 303., 454., 311., 466., 319., 478., 327., 490., 335., 502.,
      343., 514., 351., 526., 359., 538., 367., 550., 375., 562., 383., 574.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,   10.,  15.,  22.,  23.,  34.,  31.,  46.,  39.,  58.,  47.,  70.,
      55.,  82.,  63.,  94.,  71.,  106., 79.,  118., 87.,  130., 95.,  142.,
      103., 154., 111., 166., 119., 178., 127., 190., 135., 202., 143., 214.,
      151., 226., 159., 238., 167., 250., 175., 262., 183., 274., 191., 286.,
      199., 298., 207., 310., 215., 322., 223., 334., 231., 346., 239., 358.,
      247., 370., 255., 382., 263., 394., 271., 406., 279., 418., 287., 430.,
      295., 442., 303., 454., 311., 466., 319., 478., 327., 490., 335., 502.,
      343., 514., 351., 526., 359., 538., 367., 550., 375., 562., 383., 574.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,   14.,  17.,   20.,   23.,  30.,  37.,   44.,   35.,  46.,  57.,
      68.,   47.,  62.,   77.,   92.,  59.,  78.,   97.,   116., 71.,  94.,
      117.,  140., 83.,   110.,  137., 164., 95.,   126.,  157., 188., 107.,
      142.,  177., 212.,  119.,  158., 197., 236.,  131.,  174., 217., 260.,
      143.,  190., 237.,  284.,  155., 206., 257.,  308.,  167., 222., 277.,
      332.,  179., 238.,  297.,  356., 191., 254.,  317.,  380., 203., 270.,
      337.,  404., 215.,  286.,  357., 428., 227.,  302.,  377., 452., 239.,
      318.,  397., 476.,  251.,  334., 417., 500.,  263.,  350., 437., 524.,
      275.,  366., 457.,  548.,  287., 382., 477.,  572.,  299., 398., 497.,
      596.,  311., 414.,  517.,  620., 323., 430.,  537.,  644., 335., 446.,
      557.,  668., 347.,  462.,  577., 692., 359.,  478.,  597., 716., 371.,
      494.,  617., 740.,  383.,  510., 637., 764.,  395.,  526., 657., 788.,
      407.,  542., 677.,  812.,  419., 558., 697.,  836.,  431., 574., 717.,
      860.,  443., 590.,  737.,  884., 455., 606.,  757.,  908., 467., 622.,
      777.,  932., 479.,  638.,  797., 956., 491.,  654.,  817., 980., 503.,
      670.,  837., 1004., 515.,  686., 857., 1028., 527.,  702., 877., 1052.,
      539.,  718., 897.,  1076., 551., 734., 917.,  1100., 563., 750., 937.,
      1124., 575., 766.,  957.,  1148.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,   14.,  17.,   20.,   23.,  30.,  37.,   44.,   35.,  46.,  57.,
      68.,   47.,  62.,   77.,   92.,  59.,  78.,   97.,   116., 71.,  94.,
      117.,  140., 83.,   110.,  137., 164., 95.,   126.,  157., 188., 107.,
      142.,  177., 212.,  119.,  158., 197., 236.,  131.,  174., 217., 260.,
      143.,  190., 237.,  284.,  155., 206., 257.,  308.,  167., 222., 277.,
      332.,  179., 238.,  297.,  356., 191., 254.,  317.,  380., 203., 270.,
      337.,  404., 215.,  286.,  357., 428., 227.,  302.,  377., 452., 239.,
      318.,  397., 476.,  251.,  334., 417., 500.,  263.,  350., 437., 524.,
      275.,  366., 457.,  548.,  287., 382., 477.,  572.,  299., 398., 497.,
      596.,  311., 414.,  517.,  620., 323., 430.,  537.,  644., 335., 446.,
      557.,  668., 347.,  462.,  577., 692., 359.,  478.,  597., 716., 371.,
      494.,  617., 740.,  383.,  510., 637., 764.,  395.,  526., 657., 788.,
      407.,  542., 677.,  812.,  419., 558., 697.,  836.,  431., 574., 717.,
      860.,  443., 590.,  737.,  884., 455., 606.,  757.,  908., 467., 622.,
      777.,  932., 479.,  638.,  797., 956., 491.,  654.,  817., 980., 503.,
      670.,  837., 1004., 515.,  686., 857., 1028., 527.,  702., 877., 1052.,
      539.,  718., 897.,  1076., 551., 734., 917.,  1100., 563., 750., 937.,
      1124., 575., 766.,  957.,  1148.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,  390.,
      430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,  750.,  790.,
      830.,  870.,  910.,  950.,  990.,  1030., 1070., 1110., 1150., 1190.,
      1230., 1270., 1310., 1350., 1390., 1430., 1470., 1510., 1550., 1590.,
      1630., 1670., 1710., 1750., 1790., 1830., 1870., 1910.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   110.,  150.,  190.,  230.,  270.,  310.,  350.,  390.,
      430.,  470.,  510.,  550.,  590.,  630.,  670.,  710.,  750.,  790.,
      830.,  870.,  910.,  950.,  990.,  1030., 1070., 1110., 1150., 1190.,
      1230., 1270., 1310., 1350., 1390., 1430., 1470., 1510., 1550., 1590.,
      1630., 1670., 1710., 1750., 1790., 1830., 1870., 1910.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,  380.,
      370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,  626.,  780.,
      690.,  860.,  754.,  940.,  818.,  1020., 882.,  1100., 946.,  1180.,
      1010., 1260., 1074., 1340., 1138., 1420., 1202., 1500., 1266., 1580.,
      1330., 1660., 1394., 1740., 1458., 1820., 1522., 1900., 1586., 1980.,
      1650., 2060., 1714., 2140., 1778., 2220., 1842., 2300., 1906., 2380.,
      1970., 2460., 2034., 2540., 2098., 2620., 2162., 2700., 2226., 2780.,
      2290., 2860., 2354., 2940., 2418., 3020., 2482., 3100., 2546., 3180.,
      2610., 3260., 2674., 3340., 2738., 3420., 2802., 3500., 2866., 3580.,
      2930., 3660., 2994., 3740., 3058., 3820.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50.,   60.,   114.,  140.,  178.,  220.,  242.,  300.,  306.,  380.,
      370.,  460.,  434.,  540.,  498.,  620.,  562.,  700.,  626.,  780.,
      690.,  860.,  754.,  940.,  818.,  1020., 882.,  1100., 946.,  1180.,
      1010., 1260., 1074., 1340., 1138., 1420., 1202., 1500., 1266., 1580.,
      1330., 1660., 1394., 1740., 1458., 1820., 1522., 1900., 1586., 1980.,
      1650., 2060., 1714., 2140., 1778., 2220., 1842., 2300., 1906., 2380.,
      1970., 2460., 2034., 2540., 2098., 2620., 2162., 2700., 2226., 2780.,
      2290., 2860., 2354., 2940., 2418., 3020., 2482., 3100., 2546., 3180.,
      2610., 3260., 2674., 3340., 2738., 3420., 2802., 3500., 2866., 3580.,
      2930., 3660., 2994., 3740., 3058., 3820.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, SAME3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800., 2778., 3172., 3566., 3960.,
      2890., 3300., 3710., 4120., 3002., 3428., 3854., 4280., 3114., 3556.,
      3998., 4440., 3226., 3684., 4142., 4600., 3338., 3812., 4286., 4760.,
      3450., 3940., 4430., 4920., 3562., 4068., 4574., 5080., 3674., 4196.,
      4718., 5240., 3786., 4324., 4862., 5400., 3898., 4452., 5006., 5560.,
      4010., 4580., 5150., 5720., 4122., 4708., 5294., 5880., 4234., 4836.,
      5438., 6040., 4346., 4964., 5582., 6200., 4458., 5092., 5726., 6360.,
      4570., 5220., 5870., 6520., 4682., 5348., 6014., 6680., 4794., 5476.,
      6158., 6840., 4906., 5604., 6302., 7000., 5018., 5732., 6446., 7160.,
      5130., 5860., 6590., 7320., 5242., 5988., 6734., 7480., 5354., 6116.,
      6878., 7640.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow1Stride1, VALID3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      90.,   100.,  110.,  120.,  202.,  228.,  254.,  280.,  314.,  356.,
      398.,  440.,  426.,  484.,  542.,  600.,  538.,  612.,  686.,  760.,
      650.,  740.,  830.,  920.,  762.,  868.,  974.,  1080., 874.,  996.,
      1118., 1240., 986.,  1124., 1262., 1400., 1098., 1252., 1406., 1560.,
      1210., 1380., 1550., 1720., 1322., 1508., 1694., 1880., 1434., 1636.,
      1838., 2040., 1546., 1764., 1982., 2200., 1658., 1892., 2126., 2360.,
      1770., 2020., 2270., 2520., 1882., 2148., 2414., 2680., 1994., 2276.,
      2558., 2840., 2106., 2404., 2702., 3000., 2218., 2532., 2846., 3160.,
      2330., 2660., 2990., 3320., 2442., 2788., 3134., 3480., 2554., 2916.,
      3278., 3640., 2666., 3044., 3422., 3800., 2778., 3172., 3566., 3960.,
      2890., 3300., 3710., 4120., 3002., 3428., 3854., 4280., 3114., 3556.,
      3998., 4440., 3226., 3684., 4142., 4600., 3338., 3812., 4286., 4760.,
      3450., 3940., 4430., 4920., 3562., 4068., 4574., 5080., 3674., 4196.,
      4718., 5240., 3786., 4324., 4862., 5400., 3898., 4452., 5006., 5560.,
      4010., 4580., 5150., 5720., 4122., 4708., 5294., 5880., 4234., 4836.,
      5438., 6040., 4346., 4964., 5582., 6200., 4458., 5092., 5726., 6360.,
      4570., 5220., 5870., 6520., 4682., 5348., 6014., 6680., 4794., 5476.,
      6158., 6840., 4906., 5604., 6302., 7000., 5018., 5732., 6446., 7160.,
      5130., 5860., 6590., 7320., 5242., 5988., 6734., 7480., 5354., 6116.,
      6878., 7640.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}